#ifndef JOB_SCHEDULER_H
#define JOB_SCHEDULER_H

#include "JobInterface.h"
#include <vector>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <chrono>
#include <map>
#include <string>

// 前向声明
struct ThreadStatus;
struct JobStats;

/**
 * @brief 智能任务调度器类
 * 负责任务调度、线程管理、监控统计等功能
 */
class JobScheduler {
public:
    /**
     * @brief 构造函数
     */
    JobScheduler();
    
    /**
     * @brief 析构函数
     */
    ~JobScheduler();
    
    /**
     * @brief 注入任务实例列表
     * @param jobs 任务实例列表
     */
    void setJobs(const std::vector<std::shared_ptr<JobInterface>>& jobs);
    
    /**
     * @brief 注入手动策略
     * @param taskGroups 任务分组列表（每组对应一个线程）
     */
    void setManualStrategy(const std::vector<std::vector<std::string>>& taskGroups);
    
    /**
     * @brief 初始化调度器
     * 根据注入信息生成调度策略并初始化线程池
     */
    void initialize();
    
    /**
     * @brief 优雅关闭调度器
     */
    void shutdown();
    
    /**
     * @brief 获取线程状态
     * @return 线程状态列表
     */
    std::vector<ThreadStatus> getThreadStatus() const;
    
    /**
     * @brief 获取任务统计信息
     * @return 任务统计信息列表
     */
    std::vector<JobStats> getJobStats() const;

private:
    // 任务列表
    std::vector<std::shared_ptr<JobInterface>> jobs_;
    
    // 手动策略配置
    std::vector<std::vector<std::string>> manualStrategy_;
    
    // 线程池相关
    struct ThreadData {
        std::thread thread;
        std::vector<std::shared_ptr<JobInterface>> jobs;
        std::atomic<bool> running{true};
        int id;
        std::string name;  // 线程名称
    };
    
    std::vector<std::unique_ptr<ThreadData>> threadPool_;
    
    // 统计信息
    struct JobStatistics {
        std::string jobId;
        std::atomic<long long> executionCount{0};
        std::atomic<long long> totalTimeMs{0};
        std::atomic<long long> maxTimeMs{0};
        std::atomic<long long> minTimeMs{std::numeric_limits<long long>::max()};
        std::atomic<long long> timeoutCount{0};
        std::chrono::steady_clock::time_point lastExecutionTime;
    };
    
    mutable std::mutex statsMutex_;
    std::map<std::string, std::unique_ptr<JobStatistics>> jobStats_;
    
    // 状态标志
    std::atomic<bool> initialized_{false};
    std::atomic<bool> shutdown_{false};
    
    // 私有方法
    void generateSchedulingStrategy();
    void createThreadPool();
    void logSchedulingStrategy();
    static void threadWorker(ThreadData* threadData, JobScheduler* scheduler);
    void updateJobStats(const std::string& jobId, long long executionTimeMs, bool timeout);
    std::string getThreadName(int threadId) const;
};

/**
 * @brief 线程状态结构体
 */
struct ThreadStatus {
    int id;                         // 线程ID
    std::string name;               // 线程名称
    std::string status;             // 线程状态（运行中/空闲等）
    int jobCount;                  // 负责的任务数量
    std::chrono::steady_clock::time_point lastActiveTime; // 最后活跃时间
};

/**
 * @brief 任务统计信息结构体
 */
struct JobStats {
    std::string jobId;             // 任务ID
    long long executionCount;       // 执行次数
    double averageTimeMs;           // 平均执行时间（毫秒）
    long long maxTimeMs;            // 最大执行时间（毫秒）
    long long minTimeMs;            // 最小执行时间（毫秒）
    long long timeoutCount;         // 超时次数
    std::chrono::steady_clock::time_point lastExecutionTime; // 最后执行时间
};

#endif // JOB_SCHEDULER_H